#include "helpfunction.h"
#include <vector>
#include <QRandomGenerator>

int HelpFunction::getRandomInt(int min, int max) {
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(min, max);
    return dis(gen);
}
// 检查指定位置是否已被占用
bool HelpFunction::isPositionTaken(const std::vector<std::pair<int, int>>& takenPositions, int row, int col) {
    if(row==3&&col==3){return true;}
    for (const auto& pos : takenPositions) {
        if (pos.first == row && pos.second == col) {
            return true;
        }

    }
    return false;
}
// 填充矩阵的函数
std::vector<std::vector<int>>HelpFunction::randomfillMatrix(int size, int numOnes, int numTwos,int numThrees) {
    std::vector<std::vector<int>> matrix(size, std::vector<int>(size, 0)); // 初始化矩阵为全0
    std::vector<std::pair<int, int>> takenPositions; // 用于跟踪已放置1,2,3的位置

    // 填充1
    while (numOnes > 0) {
        int row, col;
        do {
            row = getRandomInt(0, size - 1);
            col = getRandomInt(0, size - 1);
        } while (isPositionTaken(takenPositions, row, col)); // 确保位置未被占用

        matrix[row][col] = 1;
        takenPositions.push_back({row, col});
        --numOnes;
    }

    // 填充2
    while (numTwos > 0) {
        int row, col;
        do {
            row = getRandomInt(0, size - 1);
            col = getRandomInt(0, size - 1);
        } while (isPositionTaken(takenPositions, row, col) || matrix[row][col] != 0); // 确保位置未被占用且原本为0

        matrix[row][col] = 2;
        takenPositions.push_back({row, col});
        --numTwos;
    }

    while (numThrees > 0) {
        int row, col;
        do {
            row = getRandomInt(0, size - 1);
            col = getRandomInt(0, size - 1);
        } while (isPositionTaken(takenPositions, row, col) || matrix[row][col] != 0); // 确保位置未被占用且原本为0

        matrix[row][col] = 3;
        takenPositions.push_back({row, col});
        --numThrees;
    }
    return matrix;
}
QList<QList<int>> HelpFunction::convertMatrix(const std::vector<std::vector<int>>& vecMatrix) {
    QList<QList<int>> qListMatrix;
    for (const auto& vecRow : vecMatrix) {
        QList<int> qListRow;
        for (int val : vecRow) {
            qListRow.append(val);
        }
        qListMatrix.append(qListRow);
    }
    return qListMatrix;
}


#include <vector>
#include <queue>
#include <utility>

using namespace std;

// 定义方向数组，用于BFS中的上下左右移动
const int dx[] = { -1, 0, 1, 0 };
const int dy[] = { 0, 1, 0, -1 };

// 使用BFS判断是否存在从start到end的路径
bool canReach(vector<vector<int>>& matrix, pair<int, int> start, pair<int, int> end) {
    int n = matrix.size(); // 矩阵的大小
    if (n == 0 || start.first < 0 || start.first >= n || start.second < 0 || start.second >= n ||
        end.first < 0 || end.first >= n || end.second < 0 || end.second >= n) {
        // 如果矩阵为空或起点、终点坐标无效，直接返回false
        return false;
    }
    vector<vector<bool>> visited(n, vector<bool>(n, false)); // 标记已访问的位置

    queue<pair<int, int>> q; // BFS队列
    q.push(start); // 将起点加入队列
    visited[start.first][start.second] = true; // 标记起点为已访问

    while (!q.empty()) {
        pair<int, int> curr = q.front(); // 取出队首元素
        q.pop();

        // 如果当前位置是终点，则返回true
        if (curr == end) {
            return true;
        }

        // 尝试四个方向的移动
        for (int i = 0; i < 4; ++i) {
            int newX = curr.first + dx[i];
            int newY = curr.second + dy[i];

            // 检查新坐标是否有效、是否可访问且未被访问过
            if (newX >= 0 && newX < n && newY >= 0 && newY < n && matrix[newX][newY] == 0 && !visited[newX][newY]) {
                q.push({ newX, newY }); // 将新位置加入队列
                visited[newX][newY] = true; // 标记新位置为已访问
            }
        }
    }

    // 如果遍历完所有可达位置后仍未找到终点，则返回false
    return false;
}




